package com.jcrj.action.flow;

import com.jcrj.action.BaseAction;
import com.jcrj.entity.OAuthority;
import com.jcrj.entity.OFlowFormProporty;
import com.jcrj.entity.OFlowType;
import com.jcrj.entity.OFormDefinition;
import com.jcrj.entity.ONode;
import com.jcrj.entity.ONodeTransaction;
import com.jcrj.entity.OProcessinstance;
import com.jcrj.entity.OUser;
import com.jcrj.entity.OWorkflow;
import com.jcrj.entity.TemplateFile;
import com.jcrj.service.FlowFormService;
import com.jcrj.service.SysLogService;
import com.jcrj.service.WorkflowManagerService;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletResponse;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

public class WorkFlowAction extends BaseAction {
	private OWorkflow workflow;
	private List<OWorkflow> workList;
	private WorkflowManagerService workflowManagerService;
	private FlowFormService flowFormService;
	private Integer flowId;
	private String status;
	private long pageCount;
	private long totalCount;
	private OFlowType flowType;
	private String[] ids;
	private int flowTypeId;
	private int nodeId;
	private List<OFlowType> flowtypelist;
	private String orgs;
	private String names;
	private String actorids;
	private String actornames;
	private ONode node;
	private ONodeTransaction nodeTransaction;
	private String users;
	private List<ONode> nodeList;
	private List<ONode> frontNotes;
	private List<ONode> backNotes;
	private List<ONode> chosenBackNode;
	private List<OFormDefinition> formList;
	private List<OFlowFormProporty> formProportyList;
	private List<OFlowFormProporty> chosenFormPropertyList;
	private String propertyid;
	private Integer formId;
	private String nodeIds;
	private OFormDefinition definition;
	private List<TemplateFile> templateList;
	private String json;
	private List docList;
	private int tableId;
	private String typeId;
	private String instanceId;
	private OProcessinstance instance;
	private String orgId;
	private String message;
	private SysLogService sysLogService;

	public String workFlowFormDraft() {
		this.workflow = this.workflowManagerService.getWorkflow(this.flowId.intValue());
		this.definition = this.flowFormService.getFormDefinition(this.workflow.getFormId().intValue());
		System.out.println(JSONObject.fromObject(definition).toString());
		this.node = this.workflowManagerService.getStartNode(this.flowId.intValue());
		return "success";
	}

	public String workFlowFormBack() {
		this.workflow = this.workflowManagerService.getWorkflow(this.flowId.intValue());
		this.definition = this.flowFormService.getFormDefinition(this.workflow.getFormId().intValue());
		this.node = this.workflowManagerService.getStartNode(this.flowId.intValue());
		return "success";
	}

	public String initFlowFormValueWrite() {
		try {
			super.getResponse().setCharacterEncoding("utf-8");
			OUser user = (OUser) super.getSession().get("userInfo");
			List list = this.workflowManagerService.getChosenFlowPropertyList(this.flowId.intValue());
			JSONObject json = new JSONObject();
			json.put("proportyList", list);
			super.getResponse().getWriter().write(json.toString());
			super.getResponse().getWriter().flush();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String initFormValueWrite() {
		try {
			super.getResponse().setCharacterEncoding("utf-8");
			OUser user = (OUser) super.getSession().get("userInfo");
			List<OFlowFormProporty> list = this.workflowManagerService.getWriteProportyList(this.nodeIds, user);
			JSONObject json = new JSONObject();
			json.put("proportyList", list);
			super.getResponse().getWriter().write(json.toString());
			super.getResponse().getWriter().flush();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String getOrgWorkFlow() {
		try {
			OUser ou = (OUser) super.getSession().get("userInfo");
			this.workList = this.workflowManagerService.getOrgWorkFlow(ou);
			if (this.workList.size() > 0)
				this.flowtypelist = this.workflowManagerService.getFlowTypeList(this.workList);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return "success";
	}

	public String flowTypeSave() {
		return "success";
	}

	public String flowTypeUpdate() {
		this.flowType = this.workflowManagerService.getFlowType(this.flowTypeId);
		return "success";
	}

	public String saveFlowType() {
		try {
			OUser ou = (OUser) super.getSession().get("userInfo");
			this.flowType.setCreateTime(new Date());
			this.flowType.setUserId(ou.getId());
			this.flowType.setUsername(ou.getName());
			this.workflowManagerService.saveFlowType(this.flowType);
			this.sysLogService.saveLog("工作流程", ou.getName(), "添加了" + this.flowType.getName() + "的流程分类");
			super.getResponse().getWriter().write("success");
			super.getResponse().getWriter().flush();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String updateFlowType() {
		try {
			OUser ou = (OUser) super.getSession().get("userInfo");
			this.flowType.setCreateTime(new Date());
			this.workflowManagerService.updateFlowType(this.flowType);
			this.sysLogService.saveLog("工作流程", ou.getName(), "修改了" + this.flowType.getName() + "的流程分类");
			super.getResponse().getWriter().write("success");
			super.getResponse().getWriter().flush();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String deleteFlowType() {
		try {
			OUser ou = (OUser) super.getSession().get("userInfo");
			this.workflowManagerService.deleteFlowType(this.ids);
			this.sysLogService.saveLog("工作流程", ou.getName(), "删除了某些流程分类");
			super.getResponse().getWriter().write("success");
			super.getResponse().getWriter().flush();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String getFlowTypes() {
		this.totalCount = this.workflowManagerService.countFlowType();
		this.pageCount = ((this.totalCount - 1L) / 10L + 1L);
		if (super.getCurrentPage() > this.pageCount) {
			super.setCurrentPage(Long.valueOf(this.pageCount).intValue());
		}
		this.flowtypelist = this.workflowManagerService.getFlowTypeList(super.getCurrentPage());
		return "success";
	}

	public String workFlow_init() {
		return "success";
	}

	public String getFormProportyByFormId() {
		try {
			super.getResponse().setCharacterEncoding("UTF-8");
			List list = this.flowFormService.flowFormProportyList(this.formId);
			JSONObject json = new JSONObject();
			json.put("proportyList", list);
			super.getResponse().getWriter().write(json.toString());
			super.getResponse().getWriter().flush();
		} catch (IOException e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String workFlowSave() {
		this.flowtypelist = this.workflowManagerService.getFlowTypeList();
		this.formList = this.flowFormService.getFormDefinitionList();
		return "success";
	}

	public String getWorkFlowById() {
		this.workflow = this.workflowManagerService.getWorkflow(this.flowId.intValue());
		if ((this.workflow.getAuthority() == null) || ("".equals(this.workflow.getAuthority()))) {
			List<OAuthority> list = this.workflowManagerService.getAuthorityFlow(this.flowId.intValue());
			if ((list != null) && (!list.isEmpty())) {
				this.orgs = "";
				this.names = "";
				this.actorids = "";
				this.actornames = "";
				for (OAuthority a : list) {
					if ("org".equals(a.getType())) {
						if ("".equals(this.orgs)) {
							this.orgs = a.getOrgId().toString();
							this.names = a.getOrgName();
						} else {
							this.orgs = (this.orgs + "," + a.getOrgId());
							this.names = (this.names + "," + a.getOrgName());
						}
					} else if ("user".equals(a.getType())) {
						if ("".equals(this.actorids)) {
							this.actorids = a.getOrgId().toString();
							this.actornames = a.getOrgName();
						} else {
							this.actorids = (this.actorids + "," + a.getOrgId());
							this.actornames = (this.actornames + "," + a.getOrgName());
						}
					}
				}
			}
		}
		this.flowtypelist = this.workflowManagerService.getFlowTypeList();
		this.formList = this.flowFormService.getFormDefinitionList();
		this.chosenFormPropertyList = this.workflowManagerService.getChosenFlowPropertyList(this.workflow.getId().intValue());
		OFormDefinition definition = this.flowFormService.getFormDefinition(this.workflow.getFormId().intValue());
		if (definition != null) {
			this.formProportyList = this.workflowManagerService.getUnChosenPropertyList(definition.getFormId().intValue(), this.chosenFormPropertyList);
		}
		return "success";
	}

	public String getWorkFlows() {
		OUser user = (OUser) super.getSession().get("userInfo");
		this.totalCount = this.workflowManagerService.countWorkFlow(this.typeId, this.names);
		this.pageCount = ((this.totalCount - 1L) / 10L + 1L);
		if (super.getCurrentPage() > this.pageCount) {
			super.setCurrentPage(Long.valueOf(this.pageCount).intValue());
		}
		this.workList = this.workflowManagerService.getWorkFlowList(this.typeId, this.names, super.getCurrentPage());
		this.status = this.workflowManagerService.flowListHtml(this.workList, user.getId().toString());
		this.flowtypelist = this.workflowManagerService.getFlowTypeList();
		return "success";
	}

	public String flowNodeManager() {
		this.nodeList = this.workflowManagerService.findNodeListByFlow(this.flowId.intValue());
		return "success";
	}

	public String flowNode_init() {
		OWorkflow flow = this.workflowManagerService.getWorkflow(this.flowId.intValue());
		OFormDefinition definition = this.flowFormService.getFormDefinition(flow.getFormId().intValue());
		if (definition != null) {
			this.formProportyList = this.flowFormService.flowFormProportyList(definition.getFormId().intValue(), null);
		} 
		return "success";
	}

	public String saveFlowNodeForm() {
		try {
			boolean flag = this.workflowManagerService.hasStartOrEndNode(this.node.getStatus(), this.node.getFlowId().intValue());
			if (flag) {
				super.getResponse().getWriter().write("false");
				super.getResponse().getWriter().flush();
			} else {
				OUser ou = (OUser) super.getSession().get("userInfo");
				this.node.setCreateTime(new Date());
				this.node.setUserId(ou.getId());
				this.node.setUserName(ou.getName());
				this.workflowManagerService.saveFlowNode(this.node, this.propertyid, this.users);
				super.getResponse().getWriter().write("success");
				super.getResponse().getWriter().flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String getFlowNodeById() {
		OWorkflow flow = this.workflowManagerService.getWorkflow(this.flowId.intValue());
		OFormDefinition form = this.flowFormService.getFormDefinition(flow.getFormId().intValue());
		this.chosenFormPropertyList = this.workflowManagerService.getChosenPropertyList(this.nodeId);
		this.formProportyList = this.workflowManagerService.getUnChosenPropertyList(form.getFormId().intValue(), this.chosenFormPropertyList);
		this.node = this.workflowManagerService.getFlowNode(this.nodeId);
		if (this.node.getActorType() == null) {
			return "success";
		}
		List list = this.workflowManagerService.getTaskActorList(this.nodeId);
		String[] values = this.workflowManagerService.serachActorNames(list, this.node.getActorType());
		this.actorids = values[0];
		this.actornames = values[1];
		return "success";
	}

	public String updateFlowNodeForm() {
		try {
			boolean flag = this.workflowManagerService.hasStartOrEndNode(this.node.getStatus(), this.node.getFlowId().intValue(), this.node.getId());
			if (flag) {
				super.getResponse().getWriter().write(this.node.getStatus());
				super.getResponse().getWriter().flush();
			} else {
				this.node.setCreateTime(new Date());
				this.workflowManagerService.updateFlowNodeForm(this.node, this.propertyid, this.users);
				super.getResponse().getWriter().write("success");
				super.getResponse().getWriter().flush();
			}
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String nodeTransitionList() {
		this.node = this.workflowManagerService.getFlowNode(this.nodeId);
		this.frontNotes = this.workflowManagerService.findFrontNodes(this.nodeId, this.flowId.intValue(), this.node.getStatus());
		this.backNotes = this.workflowManagerService.findAllNodes(this.flowId.intValue());
		this.chosenBackNode = this.workflowManagerService.findChosenBack(this.nodeId, this.flowId.intValue(), this.node.getStatus());
		return "success";
	}

	public String saveNodeTransitionSet() {
		try {
			this.workflowManagerService.saveNodeTransitionsSet(this.nodeId, this.ids, String.valueOf(this.flowId));
			super.getResponse().getWriter().write("success");
			super.getResponse().getWriter().flush();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String getFlowOrgUser() {
		return "success";
	}

	public String updateNextNode() {
		try {
			OUser user = (OUser) super.getSession().get("userInfo");
			JSONArray jsonObject = JSONArray.fromObject(this.json);
			Map map = new HashMap();

			for (int i = 0; i < jsonObject.size(); i++) {
				JSONObject jsonNode = (JSONObject) jsonObject.get(i);
				map.put(jsonNode.getString("name"), jsonNode.getString("value").replace("\n", "\\n"));
			}
			this.workflowManagerService.updateNextNode(user, map);
			this.workflow = this.workflowManagerService.getWorkflow(Integer.parseInt((String) map.get("flowId")));
			this.sysLogService.saveLog("工作流程", user.getName(), "提交了" + this.workflow.getName() + "的工作流程");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	public String upFlowNextNode() {
		try {
			OUser user = (OUser) super.getSession().get("userInfo");
			JSONArray jsonObject = JSONArray.fromObject(this.json);
			Map map = new HashMap();
			for (int i = 0; i < jsonObject.size(); i++) {
				JSONObject jsonNode = (JSONObject) jsonObject.get(i);
				map.put(jsonNode.getString("name"), jsonNode.getString("value").replace("\n", "\\n"));
			}
			this.workflowManagerService.updateNextNodeTransaction(user, map);
			this.workflow = this.workflowManagerService.getWorkflow(Integer.parseInt((String) map.get("flowId")));
			this.sysLogService.saveLog("工作流程", user.getName(), "提交了" + this.workflow.getName() + "的工作流程");
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}

	public String rejectWorkFlow() {
		try {
			OUser user = (OUser) super.getSession().get("userInfo");
			this.workflowManagerService.updateRejectWorkFlow(this.tableId, this.flowId.intValue(), this.nodeIds, user, this.message);
			this.workflow = this.workflowManagerService.getWorkflow(this.flowId.intValue());
			this.sysLogService.saveLog("工作流程", user.getName(), "驳回了" + this.workflow.getName() + "的工作流程");
			super.getResponse().getWriter().write("success");
			super.getResponse().getWriter().flush();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String getCandidate() {
		return "success";
	}

	public String nodeExecutorTree() {
		try {
			super.getResponse().setCharacterEncoding("UTF-8");
			String org = "[{\"id\": \"0\", \"text\": \"候选人名单\", \"iconCls\":\"icon-ok\"}]";
			super.getResponse().getWriter().write(org);
			super.getResponse().getWriter().flush();
		} catch (IOException e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String getNodeExecutor() {
		try {
			super.getResponse().setCharacterEncoding("UTF-8");
			List actorList = this.workflowManagerService.getExecutorList(this.nodeId);
			String org = this.workflowManagerService.getAllCandidate(actorList);
			super.getResponse().getWriter().write(org);
			super.getResponse().getWriter().flush();
		} catch (IOException e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String getOrgExecutorTree() {
		try {
			super.getResponse().setCharacterEncoding("UTF-8");
			List list = this.workflowManagerService.getExecutorList(this.nodeId);
			String org = this.workflowManagerService.getAllOrg(list);
			super.getResponse().getWriter().write(org);
			super.getResponse().getWriter().flush();
		} catch (IOException e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String getCandidateTree() {
		try {
			super.getResponse().setCharacterEncoding("UTF-8");
			List actorList = this.workflowManagerService.getExecutorList(this.nodeId);
			List list = this.workflowManagerService.getUserList(actorList);
			JSONObject json = new JSONObject();
			json.put("userList", list);
			super.getResponse().getWriter().write(json.toString());
			super.getResponse().getWriter().flush();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String getWorkFlowSign() {
		this.workflow = this.workflowManagerService.getWorkflow(this.flowId.intValue());
		this.definition = this.flowFormService.getFormDefinition(this.workflow.getFormId().intValue());
		this.instanceId = this.flowFormService.getInstanceId(this.definition.getFormId().intValue(), this.tableId);
		this.instance = this.workflowManagerService.getProcessinstance(Integer.parseInt(this.instanceId));
		this.nodeList = this.workflowManagerService.getNextNode(this.instance.getNodeId().intValue());
		this.backNotes = this.workflowManagerService.getBackNodeList(this.instance.getId().intValue(), this.instance.getNodeId().intValue());
		return "success";
	}

	public String getWorkFlowView() {
		this.workflow = this.workflowManagerService.getWorkflow(this.flowId.intValue());
		this.definition = this.flowFormService.getFormDefinition(this.workflow.getFormId().intValue());
		this.instanceId = this.flowFormService.getInstanceId(this.definition.getFormId().intValue(), this.tableId);
		return "success";
	}

	public String getFormContent() {
		try {
			super.getResponse().setCharacterEncoding("UTF-8");
			List list = this.flowFormService.flowFormProportyList(this.formId.intValue(), null);
			String jsonData = this.flowFormService.getFormContent(this.formId.intValue(), this.tableId);
			JSONObject json = new JSONObject();
			json.put("jsonData", jsonData);
			json.put("proportyList", list);
			super.getResponse().getWriter().write(json.toString());
			super.getResponse().getWriter().flush();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String deleteWorkFlowData() {
		try {
			this.workflowManagerService.deleteWorkFlow(this.flowId.intValue(), this.tableId);
			super.getResponse().getWriter().write("success");
			super.getResponse().getWriter().flush();
		} catch (Exception e) {
			e.printStackTrace();
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e1) {
				e1.printStackTrace();
			}
		} finally {
			try {
				super.getResponse().getWriter().close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return null;
	}

	public String getOrgExecutor() {
		return "success";
	}

	public OWorkflow getWorkflow() {
		return this.workflow;
	}

	public void setWorkflow(OWorkflow workflow) {
		this.workflow = workflow;
	}

	public List<OWorkflow> getWorkList() {
		return this.workList;
	}

	public void setWorkList(List<OWorkflow> workList) {
		this.workList = workList;
	}

	public WorkflowManagerService getWorkflowManagerService() {
		return this.workflowManagerService;
	}

	public void setWorkflowManagerService(WorkflowManagerService workflowManagerService) {
		this.workflowManagerService = workflowManagerService;
	}

	public Integer getFlowId() {
		return this.flowId;
	}

	public void setFlowId(Integer flowId) {
		this.flowId = flowId;
	}

	public String getStatus() {
		return this.status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public long getPageCount() {
		return this.pageCount;
	}

	public void setPageCount(long pageCount) {
		this.pageCount = pageCount;
	}

	public long getTotalCount() {
		return this.totalCount;
	}

	public void setTotalCount(long totalCount) {
		this.totalCount = totalCount;
	}

	public OFlowType getFlowType() {
		return this.flowType;
	}

	public void setFlowType(OFlowType flowType) {
		this.flowType = flowType;
	}

	public String[] getIds() {
		return this.ids;
	}

	public void setIds(String[] ids) {
		this.ids = ids;
	}

	public int getFlowTypeId() {
		return this.flowTypeId;
	}

	public void setFlowTypeId(int flowTypeId) {
		this.flowTypeId = flowTypeId;
	}

	public int getNodeId() {
		return this.nodeId;
	}

	public void setNodeId(int nodeId) {
		this.nodeId = nodeId;
	}

	public List<OFlowType> getFlowtypelist() {
		return this.flowtypelist;
	}

	public void setFlowtypelist(List<OFlowType> flowtypelist) {
		this.flowtypelist = flowtypelist;
	}

	public String getOrgs() {
		return this.orgs;
	}

	public void setOrgs(String orgs) {
		this.orgs = orgs;
	}

	public String getNames() {
		return this.names;
	}

	public void setNames(String names) {
		this.names = names;
	}

	public String getActorids() {
		return this.actorids;
	}

	public void setActorids(String actorids) {
		this.actorids = actorids;
	}

	public String getActornames() {
		return this.actornames;
	}

	public void setActornames(String actornames) {
		this.actornames = actornames;
	}

	public ONode getNode() {
		return this.node;
	}

	public void setNode(ONode node) {
		this.node = node;
	}

	public ONodeTransaction getNodeTransaction() {
		return this.nodeTransaction;
	}

	public void setNodeTransaction(ONodeTransaction nodeTransaction) {
		this.nodeTransaction = nodeTransaction;
	}

	public String getUsers() {
		return this.users;
	}

	public void setUsers(String users) {
		this.users = users;
	}

	public List<ONode> getNodeList() {
		return this.nodeList;
	}

	public void setNodeList(List<ONode> nodeList) {
		this.nodeList = nodeList;
	}

	public List<ONode> getFrontNotes() {
		return this.frontNotes;
	}

	public void setFrontNotes(List<ONode> frontNotes) {
		this.frontNotes = frontNotes;
	}

	public List<ONode> getBackNotes() {
		return this.backNotes;
	}

	public void setBackNotes(List<ONode> backNotes) {
		this.backNotes = backNotes;
	}

	public List<ONode> getChosenBackNode() {
		return this.chosenBackNode;
	}

	public void setChosenBackNode(List<ONode> chosenBackNode) {
		this.chosenBackNode = chosenBackNode;
	}

	public List<OFormDefinition> getFormList() {
		return this.formList;
	}

	public void setFormList(List<OFormDefinition> formList) {
		this.formList = formList;
	}

	public List<OFlowFormProporty> getFormProportyList() {
		return this.formProportyList;
	}

	public void setFormProportyList(List<OFlowFormProporty> formProportyList) {
		this.formProportyList = formProportyList;
	}

	public List<OFlowFormProporty> getChosenFormPropertyList() {
		return this.chosenFormPropertyList;
	}

	public void setChosenFormPropertyList(List<OFlowFormProporty> chosenFormPropertyList) {
		this.chosenFormPropertyList = chosenFormPropertyList;
	}

	public String getPropertyid() {
		return this.propertyid;
	}

	public void setPropertyid(String propertyid) {
		this.propertyid = propertyid;
	}

	public Integer getFormId() {
		return this.formId;
	}

	public void setFormId(Integer formId) {
		this.formId = formId;
	}

	public String getNodeIds() {
		return this.nodeIds;
	}

	public void setNodeIds(String nodeIds) {
		this.nodeIds = nodeIds;
	}

	public List<TemplateFile> getTemplateList() {
		return this.templateList;
	}

	public void setTemplateList(List<TemplateFile> templateList) {
		this.templateList = templateList;
	}

	public FlowFormService getFlowFormService() {
		return this.flowFormService;
	}

	public void setFlowFormService(FlowFormService flowFormService) {
		this.flowFormService = flowFormService;
	}

	public OFormDefinition getDefinition() {
		return this.definition;
	}

	public void setDefinition(OFormDefinition definition) {
		this.definition = definition;
	}

	public String getJson() {
		return this.json;
	}

	public void setJson(String json) {
		this.json = json;
	}

	public List getDocList() {
		return this.docList;
	}

	public void setDocList(List docList) {
		this.docList = docList;
	}

	public int getTableId() {
		return this.tableId;
	}

	public void setTableId(int tableId) {
		this.tableId = tableId;
	}

	public String getInstanceId() {
		return this.instanceId;
	}

	public void setInstanceId(String instanceId) {
		this.instanceId = instanceId;
	}

	public String getTypeId() {
		return this.typeId;
	}

	public void setTypeId(String typeId) {
		this.typeId = typeId;
	}

	public OProcessinstance getInstance() {
		return this.instance;
	}

	public void setInstance(OProcessinstance instance) {
		this.instance = instance;
	}

	public String getOrgId() {
		return this.orgId;
	}

	public void setOrgId(String orgId) {
		this.orgId = orgId;
	}

	public SysLogService getSysLogService() {
		return this.sysLogService;
	}

	public void setSysLogService(SysLogService sysLogService) {
		this.sysLogService = sysLogService;
	}

	public String getMessage() {
		return this.message;
	}

	public void setMessage(String message) {
		this.message = message;
	}
}
